package com.wzdigit.wms.hm.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.wzdigit.mes.basic.api.BasicDataItemDetailApi;
import com.wzdigit.mes.basic.api.BasicGetCustomerApi;
import com.wzdigit.mes.basic.api.GetSerialNumberApi;
import com.wzdigit.wms.hm.domain.Lotno;
import com.wzdigit.wms.hm.mapper.AsnDtlMapper;
import com.wzdigit.wms.hm.mapper.AsnHeaderMapper;
import com.wzdigit.wms.hm.mapper.GoodsMapper;
import com.wzdigit.wms.hm.mapper.LotnoMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;

/**
 * 批次号 服务类
 *
 * @author yangdongjie
 * @ZoneAttrService.java
 * @2021年1月4日上午11:16:31
 */
@Service
@Slf4j
public class LotnoService {

    @Autowired
    private LotnoMapper lotnoMapper;

    @Autowired
    private GoodsMapper goodsMapper;

//    @Autowired
//    private SkuCtrlMapper skuCtrlMapper;
//
//    @Autowired
//    private SkuMapper skuMapper;
//
//    @Autowired
//    private IfTransferDtlMapper ifTransferDtlMapper;
//
//    @Autowired
//    private TransferDtlMapper transferDtlMapper;
//
//    @Autowired
//    private LotAttrDtlMapper lotAttrDtlMapper;
//
//    @Autowired
//    private GdnHeaderMapper gdnHeaderMapper;
//
//    @Autowired
//    private GdnDtlMapper gdnDtlMapper;

    @Autowired
    private AsnHeaderMapper asnHeaderMapper;

    @Autowired
    private AsnDtlMapper asnDtlMapper;

//    @Autowired
//    private SystemMapper systemMapper;

    @Reference(version = "${dubbo.consumers.basic.SerialNumber.api.version:1.0.0}", check = false, timeout = 300000)
    private GetSerialNumberApi getSerialNumberApi;

    @Reference(version = "${dubbo.consumers.basic.data.item.detail.api:1.0.0}", check = false, timeout = 300000)
    private BasicDataItemDetailApi dataItemDetailApi;

    @Reference(version = "${dubbo.consumers.basic.customer.api:1.0.0}", check = false, timeout = 300000)
    private BasicGetCustomerApi customerApi;

    @Value(value = "${default_owner.code}")
    private String DEFAULT_OWNER;

    @Value(value = "${default_owner.name}")
    private String DEFAULT_OWNER_NAME;

    private static final SimpleDateFormat FORMAT = new SimpleDateFormat("yyyyMMdd");

    private static Integer CUSTOMER_ID;    // 默认货主

    private static final String WMS_GOODS = "WMS_GOODS";
    private static final String WMS_GDN_DTL = "WMS_GDN_DTL";
    private static final String WMS_ASN_DTL = "WMS_ASN_DTL";
    private static final String WMS_TRANSFER_DTL = "WMS_TRANSFER_DTL";
    private static final String WMS_IF_TRANSFER_DTL = "WMS_IF_TRANSFER_DTL";

    /**
     * 根据批次号获取实体
     *
     * @param lotNo
     * @return
     */
    public Lotno selectByCode(String lotNo) {
        QueryWrapper<Lotno> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("LOTNO", lotNo);
        return lotnoMapper.selectOne(queryWrapper);
    }

//    /**
//     * @param lotAttrId
//     * @return
//     */
//    public int selectCountByLotAttrId(Integer lotAttrId) {
//        QueryWrapper<Lotno> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("LOT_ATTR_ID", lotAttrId);
//        Integer count = lotnoMapper.selectCount(queryWrapper);
//        return count == null ? 0 : count;
//    }
//
//    /**
//     * SN批次属性校验
//     *
//     * @param dto
//     * @return
//     * @throws Exception
//     */
//    public Boolean existsLotno(ExistsLotnoDto dto) throws Exception {
//        QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("GOODS_SN", dto.getGoodsSn());
//        Goods goods = goodsMapper.selectOne(queryWrapper);
//        if (goods == null) {
//            return false;
//        }
//
//        QueryWrapper<Lotno> lotnoQueryWrapper = new QueryWrapper<>();
//        lotnoQueryWrapper.eq("LOTNO", goods.getGoodsSn());
//        WrapperUtils.queryWrapperLotAttr(dto, lotnoQueryWrapper);
//        Lotno lotno = lotnoMapper.selectOne(lotnoQueryWrapper);
//        return lotno != null;
//    }
//
//    /**
//     * 根据SN生成批次号
//     *
//     * @param dto
//     * @param loginName
//     * @return
//     * @throws SecurityException
//     * @throws NoSuchFieldException
//     * @throws Exception
//     */
//    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
//    public Lotno createLotnoBySn(String sn, String loginName) throws Exception {
//        // 货品清单
//        QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("GOODS_SN", sn);
//        Goods goods = goodsMapper.selectOne(queryWrapper);
//        try {
//            return this.createLotnoByGoods(goods, loginName);
//        } catch (Exception ex) {
//            throw ex;
//        }
//    }
//
//    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
//    public Lotno createLotnoByGoods(Goods goods, String loginName) throws Exception {
//        try {
//            // 货品控制
//            QueryWrapper<SkuCtrl> skuCtrlQueryWrapper = new QueryWrapper<>();
//            skuCtrlQueryWrapper.eq("SKU_ID", goods.getSkuId());
//            SkuCtrl skuCtrl = skuCtrlMapper.selectOne(skuCtrlQueryWrapper);
//
//            // 属性明细（1-12排序）
//            QueryWrapper<LotAttrDtl> lotAttrDtlQueryWrapper = new QueryWrapper<>();
//            lotAttrDtlQueryWrapper.eq("LOT_ATTR_ID", skuCtrl.getLotAttrId());
//            lotAttrDtlQueryWrapper.eq("IS_ENABLED", 1);
//            lotAttrDtlQueryWrapper.orderByAsc("ATTR_SEQ");
//            List<LotAttrDtl> lotAttrDtls = lotAttrDtlMapper.selectList(lotAttrDtlQueryWrapper);
//
//            // 入参DTO
//            CreateLotnoDto dto = new CreateLotnoDto();
//            Class<? extends CreateLotnoDto> dtoClass = dto.getClass();
//
//            // 货品清单CLASS
//            Class<? extends Goods> goodsClass = goods.getClass();
//
//            // 属性MAP（属性名称）
//            Map<String, Object> lotAttr = new LinkedHashMap<String, Object>();
//            // 属性MAP（属性编码）
//            Map<String, Object> lotAttrCode = new LinkedHashMap<String, Object>();
//
//            // 遍历设置属性明细
//            for (LotAttrDtl dtl : lotAttrDtls) {
//                String lotAttrValue = "";    // 转换后的货品清单数值
//
//                // 判断属性code是不是【WMS_GOODS】表的字段
//                if (systemMapper.existsColumn(WMS_GOODS, dtl.getAttrCode().toUpperCase())) {
//                    // 属性code转换驼峰格式，获取货品清单对应字段的数值
//                    String fieldName = StringUtils.strTransformation(dtl.getAttrCode());
//                    Field goodsField = goodsClass.getDeclaredField(fieldName);
//                    goodsField.setAccessible(true);
//
//                    // 转换数值格式
//                    Object fieldValue = goodsField.get(goods);    // 原货品清单数值
//                    if (fieldValue != null && !"".equals(fieldValue.toString())) {
//                        if (fieldValue instanceof Date) {
//                            lotAttrValue = FORMAT.format(fieldValue);
//                        } else {
//                            lotAttrValue = fieldValue.toString();
//                        }
//
//                        // 获取入参dto对应属性的set函数，进行填值
//                        Method dtoMethod = dtoClass.getMethod("setLotAttr" + dtl.getAttrSeq(), String.class);
//                        dtoMethod.setAccessible(true);
//                        dtoMethod.invoke(dto, lotAttrValue);
//                    }
//                }
//                // PUT属性JSON（key:value）
//                lotAttr.put(dtl.getAttr(), lotAttrValue);
//                lotAttrCode.put(dtl.getAttrCode(), lotAttrValue);
//            }
//            // 以json格式，key:value形式存储批次属性1-12的内容
//            dto.setLotAttr(JSON.toJSONString(lotAttr));
//            dto.setLotAttrCode(JSON.toJSONString(lotAttrCode));
//
//            // 批次属性ID
//            dto.setLotAttrId(skuCtrl.getLotAttrId());
//            // 货品
//            dto.setSkuId(skuCtrl.getSkuId());
//            // 货主
//            dto.setCustomerId(goods.getOwner());
//            return createLotno(dto, loginName, true);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 根据【发货单明细】查找批次号
//     *
//     * @param gdnDtlId
//     * @return
//     */
//    public Lotno getLotnoByGdnDtlId(Integer gdnDtlId) {
//        try {
//            // 发货单明细
//            GdnDtl gdnDtl = gdnDtlMapper.selectById(gdnDtlId);
//            if (gdnDtl.getLotno() != null) {
//                return selectByCode(gdnDtl.getLotno());
//            }
//
//            // 发货单主档
//            GdnHeader gdnHeader = gdnHeaderMapper.selectById(gdnDtl.getGdnHeaderId());
//
//            // 货品控制
//            QueryWrapper<SkuCtrl> skuCtrlQueryWrapper = new QueryWrapper<>();
//            skuCtrlQueryWrapper.eq("SKU_ID", gdnDtl.getSkuId());
//            SkuCtrl skuCtrl = skuCtrlMapper.selectOne(skuCtrlQueryWrapper);
//
//            // 属性明细（1-12排序）
//            QueryWrapper<LotAttrDtl> lotAttrDtlQueryWrapper = new QueryWrapper<>();
//            lotAttrDtlQueryWrapper.eq("LOT_ATTR_ID", skuCtrl.getLotAttrId());
//            lotAttrDtlQueryWrapper.eq("IS_ENABLED", 1);
//            lotAttrDtlQueryWrapper.orderByAsc("ATTR_SEQ");
//            List<LotAttrDtl> lotAttrDtls = lotAttrDtlMapper.selectList(lotAttrDtlQueryWrapper);
//
//            // 入参DTO
//            CreateLotnoDto dto = new CreateLotnoDto();
//            Class<? extends CreateLotnoDto> dtoClass = dto.getClass();
//
//            // 发货单明细CLASS
//            Class<? extends GdnDtl> gdnDtlClass = gdnDtl.getClass();
//
//            // 属性MAP（属性名称）
//            Map<String, Object> lotAttr = new LinkedHashMap<String, Object>();
//            // 属性MAP（属性编码）
//            Map<String, Object> lotAttrCode = new LinkedHashMap<String, Object>();
//
//            // 遍历设置属性明细
//            for (LotAttrDtl dtl : lotAttrDtls) {
//                // 转换后的数值
//                String lotAttrValue = "";
//
//                String fieldName = null;
//                // 转大写
//                String attrCode = dtl.getAttrCode().toUpperCase();
//                // 判断是不是发货单明细表的字段
//                if (systemMapper.existsColumn(WMS_GDN_DTL, attrCode)) {
//                    fieldName = attrCode;
//                } else {
//                    GdnLotAttrDtlEnum gdnLotAttrDtlEnum = GdnLotAttrDtlEnum.getEnumByCode(attrCode);
//                    if (gdnLotAttrDtlEnum != null) {
//                        fieldName = gdnLotAttrDtlEnum.getEnumName();
//                    }
//                }
//                if (fieldName != null) {
//                    // 转驼峰格式
//                    fieldName = StringUtils.strTransformation(fieldName);
//
//                    // 属性code转换驼峰格式，获取货品清单对应字段的数值
//                    Field gdnDtlField = gdnDtlClass.getDeclaredField(fieldName);
//                    gdnDtlField.setAccessible(true);
//
//                    // 转换数值格式
//                    Object fieldValue = gdnDtlField.get(gdnDtl);    // 原发货单明细数值
//                    if (fieldValue != null && !"".equals(fieldValue.toString())) {
//                        if (fieldValue instanceof Date) {
//                            lotAttrValue = FORMAT.format(fieldValue);
//                        } else {
//                            lotAttrValue = fieldValue.toString();
//                        }
//
//                        // 获取入参dto对应属性的set函数，进行填值
//                        Method dtoMethod = dtoClass.getMethod("setLotAttr" + dtl.getAttrSeq(), String.class);
//                        dtoMethod.setAccessible(true);
//                        dtoMethod.invoke(dto, lotAttrValue);
//                    }
//                }
//                // PUT属性JSON（key:value）
//                lotAttr.put(dtl.getAttr(), lotAttrValue);
//                lotAttrCode.put(dtl.getAttrCode(), lotAttrValue);
//            }
//            // 以json格式，key:value形式存储批次属性1-12的内容
//            dto.setLotAttr(JSON.toJSONString(lotAttr));
//            dto.setLotAttrCode(JSON.toJSONString(lotAttrCode));
//
//            // 批次属性ID
//            dto.setLotAttrId(skuCtrl.getLotAttrId());
//            // 货品
//            dto.setSkuId(skuCtrl.getSkuId());
//            // 货主
//            dto.setCustomerId(gdnHeader.getOwner());
//            return createLotno(dto, null, true);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 根据【收货单明细】查找批次号
//     *
//     * @param asnDtlId
//     * @return
//     */
//    public Lotno getLotnoByAsnDtlId(Integer asnDtlId) {
//        try {
//            // 收货单明细
//            AsnDtl asnDtl = asnDtlMapper.selectById(asnDtlId);
//            if (asnDtl.getLotno() != null) {
//                return selectByCode(asnDtl.getLotno());
//            }
//
//            // 收货单主档
//            AsnHeader asnHeader = asnHeaderMapper.selectById(asnDtl.getAsnHeaderId());
//
//            // 货品控制
//            QueryWrapper<SkuCtrl> skuCtrlQueryWrapper = new QueryWrapper<>();
//            skuCtrlQueryWrapper.eq("SKU_ID", asnDtl.getSkuId());
//            SkuCtrl skuCtrl = skuCtrlMapper.selectOne(skuCtrlQueryWrapper);
//
//            // 属性明细（1-12排序）
//            QueryWrapper<LotAttrDtl> lotAttrDtlQueryWrapper = new QueryWrapper<>();
//            lotAttrDtlQueryWrapper.eq("LOT_ATTR_ID", skuCtrl.getLotAttrId());
//            lotAttrDtlQueryWrapper.eq("IS_ENABLED", 1);
//            lotAttrDtlQueryWrapper.orderByAsc("ATTR_SEQ");
//            List<LotAttrDtl> lotAttrDtls = lotAttrDtlMapper.selectList(lotAttrDtlQueryWrapper);
//
//            // 入参DTO
//            CreateLotnoDto dto = new CreateLotnoDto();
//            Class<? extends CreateLotnoDto> dtoClass = dto.getClass();
//
//            // 收货单明细CLASS
//            Class<? extends AsnDtl> asnDtlClass = asnDtl.getClass();
//
//            // 属性MAP（属性名称）
//            Map<String, Object> lotAttr = new LinkedHashMap<String, Object>();
//            // 属性MAP（属性编码）
//            Map<String, Object> lotAttrCode = new LinkedHashMap<String, Object>();
//
//            // 遍历设置属性明细
//            for (LotAttrDtl dtl : lotAttrDtls) {
//                // 转换后的数值
//                String lotAttrValue = "";
//
//                String fieldName = null;
//                // 转大写
//                String attrCode = dtl.getAttrCode().toUpperCase();
//                // 判断是不是收货单明细表的字段
//                if (systemMapper.existsColumn(WMS_ASN_DTL, attrCode)) {
//                    fieldName = attrCode;
//                } else {
//                    AsnLotAttrDtlEnum asnLotAttrDtlEnum = AsnLotAttrDtlEnum.getEnumByCode(attrCode);
//                    if (asnLotAttrDtlEnum != null) {
//                        fieldName = asnLotAttrDtlEnum.getEnumName();
//                    }
//                }
//                if (fieldName != null) {
//                    // 转驼峰格式
//                    fieldName = StringUtils.strTransformation(fieldName);
//
//                    // 属性code转换驼峰格式，获取货品清单对应字段的数值
//                    Field asnDtlField = asnDtlClass.getDeclaredField(fieldName);
//                    asnDtlField.setAccessible(true);
//
//                    // 转换数值格式
//                    Object fieldValue = asnDtlField.get(asnDtl);    // 原收货单明细数值
//                    if (fieldValue != null && !"".equals(fieldValue.toString())) {
//                        if (fieldValue instanceof Date) {
//                            lotAttrValue = FORMAT.format(fieldValue);
//                        } else {
//                            lotAttrValue = fieldValue.toString();
//                        }
//
//                        // 获取入参dto对应属性的set函数，进行填值
//                        Method dtoMethod = dtoClass.getMethod("setLotAttr" + dtl.getAttrSeq(), String.class);
//                        dtoMethod.setAccessible(true);
//                        dtoMethod.invoke(dto, lotAttrValue);
//                    }
//                }
//                // PUT属性JSON（key:value）
//                lotAttr.put(dtl.getAttr(), lotAttrValue);
//                lotAttrCode.put(dtl.getAttrCode(), lotAttrValue);
//            }
//            // 以json格式，key:value形式存储批次属性1-12的内容
//            dto.setLotAttr(JSON.toJSONString(lotAttr));
//            dto.setLotAttrCode(JSON.toJSONString(lotAttrCode));
//
//            // 批次属性ID
//            dto.setLotAttrId(skuCtrl.getLotAttrId());
//            // 货品
//            dto.setSkuId(skuCtrl.getSkuId());
//            // 货主
//            dto.setCustomerId(asnHeader.getOwner());
//            return createLotno(dto, null, true);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//
//    /**
//     * 根据【调拨单明细】查找批次号
//     * @param transferDtlId
//     * @param type：0=来源、1=目标
//     * @return
//     */
//    /**
//     * @param transferDtlId
//     * @return
//     */
//    public Lotno getLotnoByTransferDtlId(Integer transferDtlId, Integer type) {
//        try {
//            // 调拨单明细
//            String prefix = null;
//            TransferDtl transferDtl = transferDtlMapper.selectById(transferDtlId);
//            if (type == 0) {    // 来源
//                if (transferDtl.getFmLotno() != null) {
//                    return selectByCode(transferDtl.getFmLotno());
//                }
//                prefix = "FM_";
//            } else if (type == 1) {    // 目的
//                if (transferDtl.getToLotno() != null) {
//                    return selectByCode(transferDtl.getToLotno());
//                }
//                prefix = "TO_";
//            } else {
//                return null;
//            }
//
//            // 货品控制
//            QueryWrapper<SkuCtrl> skuCtrlQueryWrapper = new QueryWrapper<>();
//            skuCtrlQueryWrapper.eq("SKU_ID", transferDtl.getFmSku());
//            SkuCtrl skuCtrl = skuCtrlMapper.selectOne(skuCtrlQueryWrapper);
//
//            // 属性明细（1-12排序）
//            QueryWrapper<LotAttrDtl> lotAttrDtlQueryWrapper = new QueryWrapper<>();
//            lotAttrDtlQueryWrapper.eq("LOT_ATTR_ID", skuCtrl.getLotAttrId());
//            lotAttrDtlQueryWrapper.eq("IS_ENABLED", 1);
//            lotAttrDtlQueryWrapper.orderByAsc("ATTR_SEQ");
//            List<LotAttrDtl> lotAttrDtls = lotAttrDtlMapper.selectList(lotAttrDtlQueryWrapper);
//
//            // 入参DTO
//            CreateLotnoDto dto = new CreateLotnoDto();
//            Class<? extends CreateLotnoDto> dtoClass = dto.getClass();
//
//            // 调拨单单明细CLASS
//            Class<? extends TransferDtl> transferDtlClass = transferDtl.getClass();
//
//            // 属性MAP（属性名称）
//            Map<String, Object> lotAttr = new LinkedHashMap<String, Object>();
//            // 属性MAP（属性编码）
//            Map<String, Object> lotAttrCode = new LinkedHashMap<String, Object>();
//
//            // 遍历设置属性明细
//            for (LotAttrDtl dtl : lotAttrDtls) {
//                // 转换后的数值
//                String lotAttrValue = "";
//
//                String fieldName = null;
//                // 转大写
//                String attrCode = (prefix + dtl.getAttrCode()).toUpperCase();
//                // 判断是不是发货单明细表的字段
//                if (systemMapper.existsColumn(WMS_TRANSFER_DTL, attrCode)) {
//                    fieldName = attrCode;
//                } else {
//                    TransferLotAttrDtlEnum transferLotAttrDtlEnum = TransferLotAttrDtlEnum.getEnumByCode(attrCode);
//                    if (transferLotAttrDtlEnum != null) {
//                        fieldName = transferLotAttrDtlEnum.getEnumName();
//                    }
//                }
//                if (fieldName != null) {
//                    // 转驼峰格式
//                    fieldName = StringUtils.strTransformation(fieldName);
//
//                    // 属性code转换驼峰格式，获取货品清单对应字段的数值
//                    Field transferDtlField = transferDtlClass.getDeclaredField(fieldName);
//                    transferDtlField.setAccessible(true);
//
//                    // 转换数值格式
//                    Object fieldValue = transferDtlField.get(transferDtl);    // 原调拨单单明细数值
//                    if (fieldValue != null && !"".equals(fieldValue.toString())) {
//                        if (fieldValue instanceof Date) {
//                            lotAttrValue = FORMAT.format(fieldValue);
//                        } else {
//                            lotAttrValue = fieldValue.toString();
//                        }
//
//                        // 获取入参dto对应属性的set函数，进行填值
//                        Method dtoMethod = dtoClass.getMethod("setLotAttr" + dtl.getAttrSeq(), String.class);
//                        dtoMethod.setAccessible(true);
//                        dtoMethod.invoke(dto, lotAttrValue);
//                    }
//                }
//                // PUT属性JSON（key:value）
//                lotAttr.put(dtl.getAttr(), lotAttrValue);
//                lotAttrCode.put(dtl.getAttrCode(), lotAttrValue);
//            }
//            // 以json格式，key:value形式存储批次属性1-12的内容
//            dto.setLotAttr(JSON.toJSONString(lotAttr));
//            dto.setLotAttrCode(JSON.toJSONString(lotAttrCode));
//
//            // 批次属性ID
//            dto.setLotAttrId(skuCtrl.getLotAttrId());
//            // 货品
//            dto.setSkuId(skuCtrl.getSkuId());
//            // 货主
//            dto.setCustomerId(type == 0 ? transferDtl.getFmOwner() : transferDtl.getToOwner());
//            return createLotno(dto, null, true);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 根据【调拨中间表明细】查找批次号
//     *
//     * @param ifTransferDtlId
//     * @param type：0=来源、1=目标
//     * @return
//     */
//    public Lotno getLotnoByIfTransferDtlId(Integer ifTransferDtlId, Integer type) {
//        try {
//            String prefix = null;
//            if (type == 0) {            // 来源
//                prefix = "FROM_";
//            } else if (type == 1) {        // 目的
//                prefix = "TO_";
//            } else {
//                return null;
//            }
//
//            // 调拨中间表明细
//            IfTransferDtl ifTransferDtl = ifTransferDtlMapper.selectById(ifTransferDtlId);
//
//            // 获取货品
//            QueryWrapper<Sku> skuQueryWrapper = new QueryWrapper<>();
//            skuQueryWrapper.eq("SKU_CODE", ifTransferDtl.getMaterialCode());
//            Sku sku = skuMapper.selectOne(skuQueryWrapper);
//
//            // 货品控制
//            QueryWrapper<SkuCtrl> skuCtrlQueryWrapper = new QueryWrapper<>();
//            skuCtrlQueryWrapper.eq("SKU_ID", sku.getSkuId());
//            SkuCtrl skuCtrl = skuCtrlMapper.selectOne(skuCtrlQueryWrapper);
//
//            // 属性明细（1-12排序）
//            QueryWrapper<LotAttrDtl> lotAttrDtlQueryWrapper = new QueryWrapper<>();
//            lotAttrDtlQueryWrapper.eq("LOT_ATTR_ID", skuCtrl.getLotAttrId());
//            lotAttrDtlQueryWrapper.eq("IS_ENABLED", 1);
//            lotAttrDtlQueryWrapper.orderByAsc("ATTR_SEQ");
//            List<LotAttrDtl> lotAttrDtls = lotAttrDtlMapper.selectList(lotAttrDtlQueryWrapper);
//
//            // 入参DTO
//            CreateLotnoDto dto = new CreateLotnoDto();
//            Class<? extends CreateLotnoDto> dtoClass = dto.getClass();
//
//            // 调拨中间表明细CLASS
//            Class<? extends IfTransferDtl> ifTransferDtlClass = ifTransferDtl.getClass();
//
//            // 属性MAP（属性名称）
//            Map<String, Object> lotAttr = new LinkedHashMap<String, Object>();
//            // 属性MAP（属性编码）
//            Map<String, Object> lotAttrCode = new LinkedHashMap<String, Object>();
//
//            // 遍历设置属性明细
//            for (LotAttrDtl dtl : lotAttrDtls) {
//                // 转换后的数值
//                String lotAttrValue = "";
//
//                String fieldName = null;
//                // 转大写
//                String attrCode = (prefix + dtl.getAttrCode()).toUpperCase();
//                // 判断是不是发货单明细表的字段
//                if (systemMapper.existsColumn(WMS_IF_TRANSFER_DTL, attrCode)) {
//                    fieldName = attrCode;
//                } else {
//                    IfTransferLotAttrDtlEnum ifTransferLotAttrDtlEnum = IfTransferLotAttrDtlEnum.getEnumByCode(attrCode);
//                    if (ifTransferLotAttrDtlEnum != null) {
//                        fieldName = ifTransferLotAttrDtlEnum.getEnumName();
//                    }
//                }
//                if (fieldName != null) {
//                    // 转驼峰格式
//                    fieldName = StringUtils.strTransformation(fieldName);
//
//                    // 属性code转换驼峰格式，获取货品清单对应字段的数值
//                    Field ifTransferDtlField = ifTransferDtlClass.getDeclaredField(fieldName);
//                    ifTransferDtlField.setAccessible(true);
//
//                    // 转换数值格式
//                    Object fieldValue = ifTransferDtlField.get(ifTransferDtl);    // 原调拨中间表明细数值
//                    if (fieldValue != null && !"".equals(fieldValue.toString())) {
//                        if (fieldValue instanceof Date) {
//                            lotAttrValue = FORMAT.format(fieldValue);
//                        } else {
//                            lotAttrValue = fieldValue.toString();
//                        }
//
//                        // 获取入参dto对应属性的set函数，进行填值
//                        Method dtoMethod = dtoClass.getMethod("setLotAttr" + dtl.getAttrSeq(), String.class);
//                        dtoMethod.setAccessible(true);
//                        dtoMethod.invoke(dto, lotAttrValue);
//                    }
//                }
//                // PUT属性JSON（key:value）
//                lotAttr.put(dtl.getAttr(), lotAttrValue);
//                lotAttrCode.put(dtl.getAttrCode(), lotAttrValue);
//            }
//            // 以json格式，key:value形式存储批次属性1-12的内容
//            dto.setLotAttr(JSON.toJSONString(lotAttr));
//            dto.setLotAttrCode(JSON.toJSONString(lotAttrCode));
//
//            // 批次属性ID
//            dto.setLotAttrId(skuCtrl.getLotAttrId());
//            // 货品
//            dto.setSkuId(skuCtrl.getSkuId());
//            // 货主
//            dto.setCustomerId(null);
//            return createLotno(dto, null, true);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * 生成批次号
//     *
//     * @param dto
//     * @param loginName
//     * @param isCreate
//     * @return
//     * @throws Exception
//     */
//    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
//    public Lotno createLotno(CreateLotnoDto dto, String loginName, boolean isCreate) throws Exception {
//        try {
//            // 默认货主
//            if (CUSTOMER_ID == null) {
//                DataItemDetailDTO dataItem = dataItemDetailApi.getDataItemDetailByPCodeAndName(DEFAULT_OWNER, DEFAULT_OWNER_NAME);
//                CUSTOMER_ID = (dataItem == null || dataItem.getItemValue() == null ? 0 : Integer.parseInt(dataItem.getItemValue()));
//            }
//
//            // 查询批次号【货品、批次属性ID、批次属性1-12的数值】
//            QueryWrapper<Lotno> queryWrapper = new QueryWrapper<>();
//            queryWrapper.eq("SKU_ID", dto.getSkuId());
//            queryWrapper.eq("LOT_ATTR_ID", dto.getLotAttrId());
//            WrapperUtils.queryWrapperLotAttr(dto, queryWrapper);
//            Lotno lotno = lotnoMapper.selectOne(queryWrapper);
//
//            // 是否已创建
//            if (lotno == null) {
//            	/*if(!isCreate) {
//            		return null;
//            	}*/
//                // 判断货主是否为空，赋予默认货主
//                if (dto.getCustomerId() == null) {
//                    dto.setCustomerId(CUSTOMER_ID);
//                }
//
//                // 生成批次号【货主、货品、日期、'0001'】
//                Date date = new Date();
//                if (StringUtils.isNull(loginName)) {
//                    loginName = CommonString.DEFAULT_USER_NAME;
//                }
//
//                String prefix = dto.getCustomerId() + dto.getSkuId() + FORMAT.format(date) + "0001";
//                List<String> lotnos = getSerialNumberApi.getSerialNumber("WMS_LOTNO", prefix, 6, 1, true, "10");
//
//                lotno = new Lotno();
//                BeanUtil.copyNonNull(dto, lotno);
//                lotno.setCreateUser(loginName);
//                lotno.setLotno(lotnos.get(0));
//                lotno.setCreateTime(date);
//
//                lotnoMapper.insert(lotno);
//                log.info("创建新的批次号：" + lotnos.get(0));
//            }
//            return lotno;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
}